package cn.xspace.app.filemg.util;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.media.ThumbnailUtils;
import android.os.Environment;
import android.provider.MediaStore;
import android.util.TypedValue;

import com.xspace.android.xafcommon.util.Constants;

import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.math.BigDecimal;


public class FileMg {
	public static float dip2pixel(Context paramContext, float paramFloat) {
		return TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_SP,
				paramFloat, paramContext.getResources().getDisplayMetrics());
	}

	public static final String PATH = Environment.getExternalStorageDirectory()
			.getPath();

	public static void initDir() {
		File f = new File(PATH + "/" + Constants.SPEEDPACHEGE + "");
		if (!f.exists())
			f.mkdir();
	}

	public static void saveFile(BitmapDrawable bm, String fileName) {
		BufferedOutputStream bos = null;
		Bitmap bt = bm.getBitmap();
		try {
			File dirFile = new File(PATH + "/" + Constants.SPEEDPACHEGE + "");
			if (!dirFile.exists()) {
				dirFile.mkdir();
			}
			File myCaptureFile = new File(PATH + "/" + Constants.SPEEDPACHEGE
					+ "/" + fileName);
			bos = new BufferedOutputStream(new FileOutputStream(myCaptureFile));
			bt.compress(Bitmap.CompressFormat.JPEG, 80, bos);
		} catch (Exception e) {
			e.printStackTrace();
		} finally {
			bt.recycle();
			if (bos != null) {
				try {
					bos.flush();
					bos.close();
				} catch (IOException e) {
					// TODO Auto-generated catch block
					e.printStackTrace();
				}

			}
		}
	}

	public static boolean deleteFile(String fileName) {
		boolean flag = false;
		try {
			File f = new File(PATH + "/" + Constants.SPEEDPACHEGE + "/"
					+ fileName);
			if (f.exists()) {
				if (f.isFile()) {
					f.delete();
					flag = true;
				} else if (f.isDirectory()) {
					String[] filelist = f.list();
					for (int i = 0; i < filelist.length; i++) {
						@SuppressWarnings("unused")
						File readfile = new File(fileName + filelist[i]);
						deleteFile(fileName + filelist[i]);
						flag = true;
					}
				}
			}
		} catch (Exception e) {

		}
		return flag;
	}

	public static BitmapDrawable getFile(String fileName) {
		BitmapDrawable bmd = null;
		Bitmap bm = null;
		BufferedOutputStream bos = null;
		try {
			BitmapFactory.Options options = new BitmapFactory.Options();
			options.inSampleSize = 2;
			bm = BitmapFactory.decodeFile(PATH + "/" + Constants.SPEEDPACHEGE
					+ "/" + fileName + ".jpg", options);
			bmd = new BitmapDrawable(bm);
		} catch (Exception e) {
			e.printStackTrace();
		}
		return bmd;
	}

	public static byte[] getShotImg(String fileName) {
		byte b[] = null;
		try {
			File f = new File(PATH + fileName);
			InputStream in = new FileInputStream(f);
			b = new byte[(int) f.length()]; // 创建合适文件大小的数组
			in.read(b); // 读取文件中的内容到b[]数组
			in.close();
		} catch (Exception e) {
			b = null;
		}
		return b;
	}

	private static long getFolderSize(File file) throws Exception {
		long size = 0;
		File[] fileList = file.listFiles();
		for (int i = 0; i < fileList.length; i++) {
			if (fileList[i].isDirectory()) {
				size = size + getFolderSize(fileList[i]);
			} else {
				size = size + fileList[i].length();
			}
		}
		return size;
	}

	public static long getFileSizes(File f) {
		try {

			FileInputStream fis = null;
			fis = new FileInputStream(f);
			return fis.available();

		} catch (Exception e) {
			return 0;
		}
	}

	public static String FormetFileSize(long fileS) {// 转换文件大小
		 if(fileS<=1024){
			BigDecimal   b   =   new   BigDecimal(((double) fileS));  
			double   f1   =   b.setScale(2,   BigDecimal.ROUND_HALF_UP).doubleValue();  
			return f1+"B";
		}
		else if(fileS<=1048576){
			BigDecimal   b   =   new   BigDecimal(((double) fileS / 1024));  
			double   f1   =   b.setScale(2,   BigDecimal.ROUND_HALF_UP).doubleValue();  
			return f1+"KB";
		}else{
			BigDecimal   b   =   new   BigDecimal(((double) fileS / 1048576));  
			double   f1   =   b.setScale(2,   BigDecimal.ROUND_HALF_UP).doubleValue();  
			return f1+"M";
		}
	}

	public static String getName(String file) {
		if (file != null && !"".equals(file)) {
			int index = file.lastIndexOf("/");
			if (index != -1) {
				return file.substring(index + 1);
			} else {
				return "";
			}
		}
		return null;
	}
	public static boolean fileIsExists(String fileName){
        try{
                File f=new File(fileName);
                if(!f.exists()){
                        return false;
                }
                
        }catch (Exception e) {
                // TODO: handle exception
                return false;
        }
        return true;
}
	/**
	 * 根据指定的图像路径和大小来获取缩略图 此方法有两点好处： 1.
	 * 使用较小的内存空间，第一次获取的bitmap实际上为null，只是为了读取宽度和高度，
	 * 第二次读取的bitmap是根据比例压缩过的图像，第三次读取的bitmap是所要的缩略图。 2.
	 * 缩略图对于原图像来讲没有拉伸，这里使用了2.2版本的新工具ThumbnailUtils，使 用这个工具生成的图像不会被拉伸。
	 * 
	 * @param imagePath
	 *            图像的路径
	 * @param width
	 *            指定输出图像的宽度
	 * @param height
	 *            指定输出图像的高度
	 * @return 生成的缩略图
	 */
	public static Drawable getImageThumbnail(String imagePath) {
		Bitmap bitmap = null;
		int width = 96;
		int height = 96;
		BitmapFactory.Options options = new BitmapFactory.Options();
		options.inJustDecodeBounds = true;
		// 获取这个图片的宽和高，注意此处的bitmap为null
		bitmap = BitmapFactory.decodeFile(imagePath, options);
		options.inJustDecodeBounds = false; // 设为 false
		// 计算缩放比
		int h = options.outHeight;
		int w = options.outWidth;
		int beWidth = w / width;
		int beHeight = h / height;
		int be = 1;
		if (beWidth < beHeight) {
			be = beWidth;
		} else {
			be = beHeight;
		}
		if (be <= 0) {
			be = 1;
		}
		options.inSampleSize = be;
		// 重新读入图片，读取缩放后的bitmap，注意这次要把options.inJustDecodeBounds 设为 false
		bitmap = BitmapFactory.decodeFile(imagePath, options);
		// 利用ThumbnailUtils来创建缩略图，这里要指定要缩放哪个Bitmap对象
		bitmap = ThumbnailUtils.extractThumbnail(bitmap, width, height,
				ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
		return new BitmapDrawable(bitmap);
	}

	/**
	 * 获取视频的缩略图 先通过ThumbnailUtils来创建一个视频的缩略图，然后再利用ThumbnailUtils来生成指定大小的缩略图。
	 * 如果想要的缩略图的宽和高都小于MICRO_KIND，则类型要使用MICRO_KIND作为kind的值，这样会节省内存。
	 * 
	 * @param videoPath
	 *            视频的路径
	 * @param width
	 *            指定输出视频缩略图的宽度
	 * @param height
	 *            指定输出视频缩略图的高度度
	 * @param kind
	 *            参照MediaStore.Images.Thumbnails类中的常量MINI_KIND和MICRO_KIND。
	 *            其中，MINI_KIND: 512 x 384，MICRO_KIND: 96 x 96
	 * @return 指定大小的视频缩略图
	 */
	public synchronized static Drawable getVideoThumbnail(String videoPath) {
		try {
			Bitmap bitmap = null;
			// 获取视频的缩略图
			bitmap = ThumbnailUtils.createVideoThumbnail(videoPath,
					MediaStore.Images.Thumbnails.MICRO_KIND);
			bitmap = ThumbnailUtils.extractThumbnail(bitmap, 96, 80,
					ThumbnailUtils.OPTIONS_RECYCLE_INPUT);
			return new BitmapDrawable(bitmap);
		} catch (Exception e) {
			return null;
		}
	}

}
